import request from './request'

/**
 * 模型管理API接口
 */

// ==================== 模型基础管理 ====================

/**
 * 获取支持的模型类型和算法
 * @returns {Promise}
 */
export function getModelTypes() {
  return request({
    url: '/models/types/',
    method: 'get'
  })
}

/**
 * 获取指定模型类型的算法列表
 * @param {Object} params - 查询参数
 * @param {string} params.model_type - 模型类型
 * @returns {Promise}
 */
export function getModelAlgorithms(params) {
  return request({
    url: '/models/algorithms/',
    method: 'get',
    params
  })
}

/**
 * 获取指定模型类型的数据集列表
 * @param {Object} params - 查询参数
 * @param {string} params.model_type - 模型类型
 * @returns {Promise}
 */
export function getModelDatasets(params) {
  return request({
    url: '/models/datasets/',
    method: 'get',
    params
  })
}

/**
 * 获取指定模型类型的默认配置
 * @param {Object} params - 查询参数
 * @param {string} params.model_type - 模型类型
 * @returns {Promise}
 */
export function getModelDefaultConfig(params) {
  return request({
    url: '/models/default-config/',
    method: 'get',
    params
  })
}

/**
 * 获取默认训练参数
 * @param {Object} params - 查询参数
 * @param {string} params.model_type - 模型类型
 * @param {string} params.algorithm - 算法类型
 * @returns {Promise}
 */
export function getDefaultParams(params) {
  return request({
    url: '/models/default-params/',
    method: 'get',
    params
  })
}

/**
 * 获取模型列表
 * @param {Object} params - 查询参数
 * @param {number} params.page - 页码
 * @param {number} params.pageSize - 每页数量
 * @param {string} params.keyword - 搜索关键词
 * @param {string} params.status - 状态筛选
 * @param {string} params.type - 类型筛选
 * @param {string} params.sortBy - 排序字段
 * @returns {Promise}
 */
export function getModelList(params = {}) {
  return request({
    url: '/models/list/',
    method: 'get',
    params
  })
}

/**
 * 获取模型详情
 * @param {number} id - 模型ID
 * @returns {Promise}
 */
export function getModelDetail(id) {
  return request({
    url: `/models/${id}/`,
    method: 'get'
  })
}

/**
 * 创建模型
 * @param {Object} data - 模型数据
 * @param {string} data.name - 模型名称
 * @param {string} data.type - 模型类型
 * @param {string} data.algorithm - 算法
 * @param {string} data.framework - 框架
 * @param {string} data.description - 描述
 * @returns {Promise}
 */
export function createModel(data) {
  return request({
    url: '/models/create/',
    method: 'post',
    data
  })
}

/**
 * 更新模型信息
 * @param {number} id - 模型ID
 * @param {Object} data - 模型数据
 * @returns {Promise}
 */
export function updateModel(id, data) {
  return request({
    url: `/api/models/${id}`,
    method: 'put',
    data
  })
}

/**
 * 删除模型
 * @param {number} id - 模型ID
 * @returns {Promise}
 */
export function deleteModel(id) {
  return request({
    url: `/models/${id}/delete/`,
    method: 'delete'
  })
}

/**
 * 复制模型
 * @param {number} id - 模型ID
 * @param {Object} data - 复制配置
 * @param {string} data.name - 新模型名称
 * @returns {Promise}
 */
export function copyModel(id, data) {
  return request({
    url: `/api/models/${id}/copy`,
    method: 'post',
    data
  })
}

// ==================== 模型训练相关 ====================

/**
 * 开始训练模型
 * @param {number} modelId - 模型ID
 * @returns {Promise}
 */
export function startModelTraining(modelId) {
  return request({
    url: `/models/${modelId}/start-training/`,
    method: 'post'
  })
}

/**
 * 开始训练模型 (别名)
 * @param {number} modelId - 模型ID
 * @returns {Promise}
 */
export function startTraining(modelId) {
  return startModelTraining(modelId)
}

/**
 * 停止训练
 * @param {number} trainingId - 训练任务ID
 * @returns {Promise}
 */
export function stopTraining(modelId) {
  return request({
    url: `/models/${modelId}/stop/`,
    method: 'post'
  })
}

/**
 * 获取模型状态
 * @param {number} modelId - 模型ID
 * @returns {Promise}
 */
export function getModelStatus(modelId) {
  return request({
    url: `/models/${modelId}/status/`,
    method: 'get'
  })
}

/**
 * 获取训练状态 (别名)
 * @param {number} modelId - 模型ID
 * @returns {Promise}
 */
export function getTrainingStatus(modelId) {
  return getModelStatus(modelId)
}

/**
 * 获取模型训练日志
 * @param {number} modelId - 模型ID
 * @returns {Promise}
 */
export function getModelLogs(modelId) {
  return request({
    url: `/models/${modelId}/logs/`,
    method: 'get'
  })
}

/**
 * 评估模型性能
 * @param {number} modelId - 模型ID
 * @returns {Promise}
 */
export function evaluateModel(modelId) {
  return request({
    url: `/models/${modelId}/evaluate/`,
    method: 'post'
  })
}

/**
 * 获取模型指标
 * @param {number} modelId - 模型ID
 * @returns {Promise}
 */
export function getModelMetrics(modelId) {
  return request({
    url: `/models/${modelId}/metrics/`,
    method: 'get'
  })
}

/**
 * 获取训练进度
 * @param {number} trainingId - 训练任务ID
 * @returns {Promise}
 */
export function getTrainingProgress(trainingId) {
  return request({
    url: `/api/models/train/${trainingId}/progress`,
    method: 'get'
  })
}

/**
 * 获取训练历史
 * @param {number} modelId - 模型ID
 * @returns {Promise}
 */
export function getTrainingHistory(modelId) {
  return request({
    url: `/api/models/${modelId}/training-history`,
    method: 'get'
  })
}

/**
 * 获取训练日志
 * @param {number} trainingId - 训练任务ID
 * @param {Object} params - 查询参数
 * @returns {Promise}
 */
export function getTrainingLogs(trainingId, params = {}) {
  return request({
    url: `/api/models/train/${trainingId}/logs`,
    method: 'get',
    params
  })
}

// ==================== 模型评估相关 ====================

/**
 * 运行模型评估
 * @param {number} modelId - 模型ID
 * @param {Object} data - 评估配置
 * @param {string} data.testDataset - 测试数据集
 * @param {Array} data.metrics - 评估指标
 * @returns {Promise}
 */
export function runEvaluation(modelId, data) {
  return request({
    url: `/api/models/${modelId}/evaluate`,
    method: 'post',
    data
  })
}

/**
 * 获取评估结果
 * @param {number} modelId - 模型ID
 * @param {number} evaluationId - 评估任务ID
 * @returns {Promise}
 */
export function getEvaluationResult(modelId, evaluationId) {
  return request({
    url: `/api/models/${modelId}/evaluations/${evaluationId}`,
    method: 'get'
  })
}



/**
 * 获取混淆矩阵
 * @param {number} modelId - 模型ID
 * @returns {Promise}
 */
export function getConfusionMatrix(modelId) {
  return request({
    url: `/api/models/${modelId}/confusion-matrix`,
    method: 'get'
  })
}

/**
 * 获取ROC曲线数据
 * @param {number} modelId - 模型ID
 * @returns {Promise}
 */
export function getROCCurve(modelId) {
  return request({
    url: `/api/models/${modelId}/roc-curve`,
    method: 'get'
  })
}

/**
 * 获取特征重要性
 * @param {number} modelId - 模型ID
 * @returns {Promise}
 */
export function getFeatureImportance(modelId) {
  return request({
    url: `/api/models/${modelId}/feature-importance`,
    method: 'get'
  })
}

// ==================== 模型部署相关 ====================

/**
 * 部署模型
 * @param {number} modelId - 模型ID
 * @param {Object} data - 部署配置
 * @param {string} data.environment - 部署环境
 * @param {Object} data.config - 部署配置
 * @returns {Promise}
 */
export function deployModel(modelId, data) {
  return request({
    url: `/api/models/${modelId}/deploy`,
    method: 'post',
    data
  })
}

/**
 * 停止模型部署
 * @param {number} modelId - 模型ID
 * @returns {Promise}
 */
export function undeployModel(modelId) {
  return request({
    url: `/api/models/${modelId}/undeploy`,
    method: 'post'
  })
}

/**
 * 获取部署状态
 * @param {number} modelId - 模型ID
 * @returns {Promise}
 */
export function getDeploymentStatus(modelId) {
  return request({
    url: `/api/models/${modelId}/deployment-status`,
    method: 'get'
  })
}

/**
 * 模型预测
 * @param {number} modelId - 模型ID
 * @param {Object} data - 预测数据
 * @returns {Promise}
 */
export function predictWithModel(modelId, data) {
  return request({
    url: `/models/${modelId}/predict/`,
    method: 'post',
    data
  })
}

// ==================== 模型导入导出 ====================

/**
 * 导出模型
 * @param {number} modelId - 模型ID
 * @param {Object} params - 导出参数
 * @param {string} params.format - 导出格式
 * @returns {Promise}
 */
export function exportModel(modelId, params = {}) {
  return request({
    url: `/api/models/${modelId}/export`,
    method: 'get',
    params,
    responseType: 'blob'
  })
}

/**
 * 导入模型
 * @param {FormData} formData - 包含模型文件的表单数据
 * @returns {Promise}
 */
export function importModel(formData) {
  return request({
    url: '/api/models/import',
    method: 'post',
    data: formData,
    headers: {
      'Content-Type': 'multipart/form-data'
    }
  })
}

/**
 * 下载模型文件
 * @param {number} modelId - 模型ID
 * @param {string} fileName - 文件名
 * @returns {Promise}
 */
export function downloadModelFile(modelId, fileName) {
  return request({
    url: `/api/models/${modelId}/files/${fileName}`,
    method: 'get',
    responseType: 'blob'
  })
}

// ==================== 数据集管理 ====================

/**
 * 获取可用数据集列表
 * @returns {Promise}
 */
export function getDatasets() {
  return request({
    url: '/api/models/datasets',
    method: 'get'
  })
}

/**
 * 获取数据集详情
 * @param {string} datasetId - 数据集ID
 * @returns {Promise}
 */
export function getDatasetDetail(datasetId) {
  return request({
    url: `/api/models/datasets/${datasetId}`,
    method: 'get'
  })
}

/**
 * 预览数据集
 * @param {string} datasetId - 数据集ID
 * @param {Object} params - 查询参数
 * @param {number} params.limit - 限制条数
 * @returns {Promise}
 */
export function previewDataset(datasetId, params = {}) {
  return request({
    url: `/api/models/datasets/${datasetId}/preview`,
    method: 'get',
    params
  })
}

// ==================== 算法和框架 ====================

/**
 * 获取支持的算法列表
 * @param {string} modelType - 模型类型
 * @returns {Promise}
 */
export function getSupportedAlgorithms(modelType) {
  return request({
    url: '/api/models/algorithms',
    method: 'get',
    params: { type: modelType }
  })
}

/**
 * 获取支持的框架列表
 * @returns {Promise}
 */
export function getSupportedFrameworks() {
  return request({
    url: '/api/models/frameworks',
    method: 'get'
  })
}

/**
 * 获取算法参数配置
 * @param {string} algorithm - 算法名称
 * @returns {Promise}
 */
export function getAlgorithmConfig(algorithm) {
  return request({
    url: `/api/models/algorithms/${algorithm}/config`,
    method: 'get'
  })
}

// ==================== 模型版本管理 ====================

/**
 * 获取模型版本列表
 * @param {number} modelId - 模型ID
 * @returns {Promise}
 */
export function getModelVersions(modelId) {
  return request({
    url: `/api/models/${modelId}/versions`,
    method: 'get'
  })
}

/**
 * 创建模型版本
 * @param {number} modelId - 模型ID
 * @param {Object} data - 版本数据
 * @returns {Promise}
 */
export function createModelVersion(modelId, data) {
  return request({
    url: `/api/models/${modelId}/versions`,
    method: 'post',
    data
  })
}

/**
 * 切换模型版本
 * @param {number} modelId - 模型ID
 * @param {string} version - 版本号
 * @returns {Promise}
 */
export function switchModelVersion(modelId, version) {
  return request({
    url: `/api/models/${modelId}/versions/${version}/activate`,
    method: 'post'
  })
}

// ==================== 模型监控 ====================

/**
 * 获取模型性能监控数据
 * @param {number} modelId - 模型ID
 * @param {Object} params - 查询参数
 * @returns {Promise}
 */
export function getModelMonitoring(modelId, params = {}) {
  return request({
    url: `/api/models/${modelId}/monitoring`,
    method: 'get',
    params
  })
}

/**
 * 获取模型使用统计
 * @param {number} modelId - 模型ID
 * @param {Object} params - 查询参数
 * @returns {Promise}
 */
export function getModelUsageStats(modelId, params = {}) {
  return request({
    url: `/api/models/${modelId}/usage-stats`,
    method: 'get',
    params
  })
}
